/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package Utilidades;

import java.util.regex.Pattern;

/**
 * Verifica cadenas de acuerdo a caracteres correspondientes a las diferentes
 * etiquetas XML para determinar las caracterisiticas de las mismas.
 * @author Administrador
 */
public class VerificadorStrings {
    
    private static final int IGUAL = 0; //Representa =
//    private static final int MENOS = 1;
    private static final int MAS   = 2; //Representa >

    public static boolean soloTextoGuionesYEspacios(final String aValidar) {
        boolean resultado = true;
        String[] modificar = aValidar.split(" ");

        for (int i = 0; i < modificar.length; i++) {
            String aux = modificar[i].trim();
            resultado = resultado && VerificadorStrings.soloTextosYGuiones(aux);
        }
        return resultado;
    }

    public static boolean soloTextosYGuiones(final String aValidar) {
        return VerificadorStrings.validarCaracteres(aValidar, "^[A-Za-z0-9_\\-]+$");
    }

    public static boolean hasOnlyAlphaNum(final String aValidar) {
        return VerificadorStrings.validarCaracteres(aValidar, "^[A-Za-z0-9]+$");
    }

    public static boolean validarNombreTag(final String str, final String sInicio, final String sFinal) {
        String aux=StrOp.borrarInicioFin(str, sInicio, sFinal).split(" ")[0];
        return VerificadorStrings.soloTextosYGuiones(aux);
    }

    private static boolean validarCaracteres(final String aValidar, final String caracteres) {
        Pattern p = Pattern.compile(caracteres);
        return p.matcher(aValidar).matches();
    }

    /**
     * Verifica si la cadena recibida comienza con sInicio y termina con sFinal
     * @param cadena String a controlar por el método
     * @param sInicio Verifica si cadena comienza con este String
     * @param sFinal Verifica si cadena termina con este String
     * @return booleano que representa la condición explicada
     */
    public static boolean esInicioFin(String cadena, String sInicio, String sFinal) {
        return (cadena.startsWith(sInicio) && cadena.endsWith(sFinal));
    }

    /**
     * Verifica si la cádena tiene más de "valor" veces el String "secuencia"
     * @param cadena Cadena a evaluar 
     * @param secuencia Caracteres a evaluar dentro de la cadena
     * @param valor Cantidad de valores aceptados para la evaluación
     * @param ingnorar Booleano que decide si convierte los datos a minúscula
     * @return True si es correcta la evaluación, false sino.
     */
    public static boolean tieneMasDe(String cadena, String secuencia, int valor, boolean ignorar) {
        return VerificadorStrings.evaluar(cadena, secuencia, valor, ignorar, VerificadorStrings.MAS);
    }

    /**
     * Determina si la etiqueta no tiene contenido
     * @param cadena Cadena a evaluar 
     * @param sInicio Secuencia de inicio de la etiqueta
     * @param sFinal Secuencia de fin de la etiqueta
     * @return True si está vacia, false en caso contrario
     */
    public static boolean estaVacia(String cadena, final String sInicio, final String sFinal) {
        return StrOp.borrarInicioFin(cadena, sInicio, sFinal).equals(""); //borra caracteres especiales y comopara para ver si es vacia
    }

//    public static boolean tieneMenosDe(final String cadena, final String secuencia, final int valor, final boolean ignorar) {
//        return VerificadorStrings.evaluar(cadena, secuencia, valor, ignorar, VerificadorStrings.MENOS);
//    }
    
    /**
     * Verifica que la cadena tenga un número igual de veces (valor )la secuencia
     * @param cadena Cadena a evaluar 
     * @param secuencia Caracteres a evaluar dentro de la cadena
     * @param valor Cantidad de valores aceptados para la evaluación
     * @param ingnorar Booleano que decide si convierte los datos a minúscula
     * @return True si es correcta la evaluación, false sino.
     */
    public static boolean tieneIgualDe(String cadena, String secuencia, int valor, boolean ingnorar) {
        return VerificadorStrings.evaluar(cadena, secuencia, valor, ingnorar, VerificadorStrings.IGUAL);
    }

    /**
     * Evalua la cadena con la condición recibida por parámetro
     * @param cadena Cadena a evaluar
     * @param secuencia Caracteres a evaluar dentro de la cadena
     * @param valor Cantidad de valores aceptados para la evaluación
     * @param ignorar Booleano que decide si convierte los datos a minúscula
     * @param tipo Cte que dice si hay que comparar por >, < ó =
     * @return True si es correcta la evaluación, false sino.
     */
    private static boolean evaluar(String cadena, String secuencia, int valor, boolean ignorar, int tipo) {
        boolean resultado = true;
        int[] array = VerificadorStrings.cantCaracteres(cadena, secuencia, ignorar);
        //Array es un Vector de int que identifica cuantas veces aparece cada secuencia buscado dentro de cadena

        for (int i = 0; i < array.length; i++) {
            int j = array[i];

            switch (tipo) {
                case VerificadorStrings.IGUAL:
                    resultado = resultado && (j == valor);
                    break;
//                case VerificadorStrings.MENOS:
//                    resultado = resultado && (j < valor);
//                    break;
                case VerificadorStrings.MAS:
                    resultado = resultado && (j > valor);
                    break;
                default:
                    break;
            }
        }
        return resultado;
    }

    /**
     * Crea un vector con la cantidad de veces que aparece cada caracter de secuencia dentro del cadena
     * @param cadena Cadena analizada en la que se va a buscar el secuencia
     * @param secuencia Cadena a encontrar dentro del cadena
     * @param ignorar Booleano que determina si debe convertir cadena a minuscula o no.
     * @return Vector de enteros que tiene la cantidad de veces que aparece cada caracter de secuencia
     */
    private static int[] cantCaracteres(String cadena, String secuencia, boolean ignorar) {
        int[] resultado = new int[secuencia.length()]; //vector con la cantidad de carácteres que tiene el String a encontrar
        char[] array = null; //el String a encontrar dividido en Vector de caracteres.
        String aux = null; //String que convierte la cadena analizada en minúscula en caso de ser necesario.

        if (ignorar) {//Verifica si tiene que pasar todo a minúscula o no
            aux = cadena.toLowerCase();//convierte todos los carácteres de cadena a minúscula
            array = secuencia.toLowerCase().toCharArray();
        }
        else {
            array = secuencia.toCharArray();
            aux = cadena;
        }

        for (int i = 0; i < array.length; i++) {
            char c = array[i];//variable auxiliar de array[]
            resultado[i] = VerificadorStrings.calcularCantCaracteres(aux, c);
        }
        return resultado;
    }

    /**
     * Busca cuantas veces aparece determinado caracter dentro de la cadena analizada.
     * @param cadena String analizado
     * @param caracter Simbolo que busca en la cadena, en caso de ser comilla no la tiene en cuenta
     * @return Cantidad de veces que "caracter" está dentro de la cadena.
     */
    private static int calcularCantCaracteres(String cadena, char caracter) {
        char[] array = cadena.toCharArray();
        boolean bAux = false;
        int cont = 0;

        for (int i = 0; i < array.length; i++) {
            if (array[i] == '"') {
                bAux = !bAux;
            }
            if (array[i] == caracter && bAux == false) {
                cont++;
            }
        }
        return cont;
    }
}
